home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et3_0-a1.lha / et3 / src / TextCmd.C < prev    next >
C/C++ Source or Header  |  1992-07-06  |  14KB  |  600 lines
  1. #ifdef __GNUG__
  2. #pragma implementation
  3. #endif
  4.  
  5. #include "TextCmd.h"
  6.  
  7. #include "Class.h"  
  8. #include "TextView.h" 
  9. #include "CmdNo.h"
  10. #include "StyledText.h"
  11. #include "RunArray.h"
  12. #include "Math.h"
  13.  
  14. //---- range functions ---------------------------------------------------------
  15.  
  16. void CharacterRange(Text*, int at, int *start, int *end)
  17. {
  18.     *start= *end= at;    
  19. }
  20.  
  21. void WordRange(Text *t, int at, int *start, int *end)
  22. {
  23.     t->GetWordRange(at, start, end);
  24. }
  25.  
  26. void ParagraphRange(Text *t, int at, int *start, int *end)
  27. {
  28.     t->GetParaRange(at, start, end);
  29. }
  30.  
  31. //---- RangeSelector -----------------------------------------------------------
  32.  
  33. RangeSelector::RangeSelector(class TextView *t, TextRangeFP f)
  34. {
  35.     tv= t;
  36.     range= f;
  37. }
  38.  
  39. Command *RangeSelector::TrackMouse(TrackPhase tp, Point, Point np, Point)
  40. {
  41.     SelPoint nextp;
  42.     int start, end;
  43.     
  44.     np= np-tv->GetInnerOrigin();
  45.     
  46.     switch (tp) {
  47.     case eTrackPress:
  48.     tv->DoneTyping();
  49.     tv->inTextSelector= TRUE;
  50.     tv->PointToPoint(np, &nextp.viewp, &nextp.line, &nextp.ch);
  51.     Range(tv->GetText(), nextp.ch, &start, &end);
  52.     DoPress(nextp, start, end);
  53.     break;
  54.     
  55.     case eTrackMove:
  56.     tv->PointToPoint(np, &nextp.viewp, &nextp.line, &nextp.ch);
  57.     Range(tv->GetText(), nextp.ch, &start, &end);
  58.     DoMove(nextp, start, end);
  59.     break;
  60.     
  61.     case eTrackRelease:
  62.     tv->inTextSelector= FALSE;
  63.     if ((tv->start.line == tv->end.line) && tv->Caret())
  64.         tv->InvalidateSelection();
  65.     tv->NormSelection();  
  66.     return gNoChanges;
  67.     }
  68.     return this;
  69. }
  70.  
  71. void RangeSelector::Range(Text *t, int at, int *from, int *to)
  72. {
  73.     range(t, at, from, to);
  74.     *to= Math::Min(t->End(), *to);
  75. }
  76.  
  77. void RangeSelector::DoPress(SelPoint, int s, int e)
  78. {
  79.     tv->PrivSetSelection(s, e, FALSE);
  80.     startp= tv->start;
  81.     endp= tv->end;
  82. }
  83.  
  84. void RangeSelector::DoMove(SelPoint nextp, int s, int e)
  85. {
  86.     if (nextp.ch <= startp.ch) {
  87.     tv->CharToPoint (nextp.ch= s, &nextp.line, &nextp.viewp);
  88.     if (!nextp.IsEqual(tv->start)) {
  89.         tv->InvalidateRange(nextp.line, nextp.viewp, tv->start.line, tv->start.viewp);
  90.         tv->start= nextp;
  91.     }
  92.     else if (tv->end.ch > endp.ch && !endp.IsEqual(tv->end)) {
  93.         tv->InvalidateRange(endp.line, endp.viewp, tv->end.line, tv->end.viewp);
  94.         tv->end= endp;
  95.     }            
  96.     } else {
  97.     tv->CharToPoint(nextp.ch= e, &nextp.line, &nextp.viewp);
  98.     if (!nextp.IsEqual(tv->end)) {
  99.         tv->InvalidateRange(tv->end.line, tv->end.viewp, nextp.line, nextp.viewp);
  100.         tv->end= nextp;
  101.     } 
  102.     else if (tv->start.ch < startp.ch && !startp.IsEqual(tv->start)) {
  103.         tv->InvalidateRange(tv->start.line, tv->start.viewp, startp.line, startp.viewp);
  104.         tv->start= startp;
  105.     }
  106.     }
  107. }
  108.  
  109. //---- ExtendRangeSelector ----------------------------------------------------
  110.  
  111. ExtendRangeSelector::ExtendRangeSelector(TextView *tv, TextRangeFP rf) 
  112.                             : RangeSelector(tv, rf)
  113. {
  114.     swap= FALSE;
  115. }
  116.  
  117. void ExtendRangeSelector::DoPress(SelPoint nextp, int s, int e)
  118. {
  119.     startp.ch= s;
  120.     endp.ch= e;
  121.     if (nextp.ch <= tv->start.ch) {     // extend at start 
  122.     tv->CharToPoint(startp.ch, &startp.line, &startp.viewp);
  123.     tv->InvalidateRange(startp.line, startp.viewp, tv->start.line, tv->start.viewp);
  124.     tv->start= startp;
  125.     swap= TRUE;
  126.     } else {                            // extend at end
  127.     tv->CharToPoint(endp.ch, &endp.line, &endp.viewp);
  128.     tv->InvalidateRange(tv->end.line, tv->end.viewp, endp.line, endp.viewp);
  129.     tv->end= endp;
  130.     }
  131.     startp= nextp;
  132. }
  133.  
  134. void ExtendRangeSelector::DoMove(SelPoint nextp, int s, int e)
  135. {
  136.     if (swap) {
  137.     swap= FALSE;
  138.     SwapSelPoints(tv->start, tv->end);
  139.     } 
  140.     if (nextp.ch < startp.ch)
  141.     tv->CharToPoint(nextp.ch= s, &nextp.line, &nextp.viewp);
  142.     else
  143.     tv->CharToPoint(nextp.ch= e, &nextp.line, &nextp.viewp);
  144.     
  145.     if (!nextp.IsEqual(tv->end)) {
  146.     tv->InvalidateRange(nextp.line, nextp.viewp, tv->end.line, tv->end.viewp);
  147.     tv->end= nextp;
  148.     } 
  149. }
  150.  
  151. //---- QuickPasteSelector ------------------------------------------------------
  152.  
  153. QuickPasteSelector::QuickPasteSelector(class TextView *tv, int f, int t)
  154.                                  : RangeSelector(tv)
  155. { 
  156.     from= f;
  157.     to= t;
  158. }
  159.  
  160. Command *QuickPasteSelector::TrackMouse(TrackPhase tp, Point ap, Point pp, Point np)
  161. {
  162.     Command *cmd= RangeSelector::TrackMouse(tp, ap, pp, np);
  163.     if (tp == eTrackRelease) {
  164.     if (tv->Caret()) {
  165.         tv->SetSelection(from, to);
  166.         return gNoChanges;
  167.     }
  168.     Text *t= tv->SelectionAsText();
  169.     tv->SetSelection(from, to);
  170.     return new PasteCommand(tv, t); 
  171.     }
  172.     return cmd;
  173. }
  174.  
  175. //---- DragAndDropSelector ---------------------------------------------------
  176.  
  177. GrCursor DragAndDropSelector::oldcursor;
  178.  
  179. DragAndDropSelector::DragAndDropSelector(class TextView *tvp, int s, int e, bool p)
  180. { 
  181.     dst= from= s;
  182.     to= e;
  183.     tv= tvp;
  184.     moved= FALSE;
  185.     paste= p;
  186.     t= tvp->GetText();
  187. }
  188.  
  189. Command *DragAndDropSelector::TrackMouse(TrackPhase tp, Point ap, Point, Point np)
  190. {
  191.     delta= np-ap;
  192.     switch (tp) {
  193.     case eTrackPress:
  194.     oldcursor= GrGetCursor();
  195.     break;
  196.     case eTrackMove:
  197.     if (Math::Abs(delta.x) > 4 || Math::Abs(delta.y) > 4) {
  198.         GrSetCursor(eCrsMoveHand);
  199.         moved= TRUE;
  200.     }
  201.     break;
  202.     case eTrackRelease:
  203.     GrSetCursor(oldcursor);
  204.     tv->SetSelection(dst, dst, TRUE);
  205.     if (moved && !(dst >= from && dst < to)) {
  206.         Text *txtsrc= t->Save(from, to);
  207.         tv->SetSelection(dst, dst, TRUE);
  208.         if (paste || tv->DeleteRequest(from, to) == FALSE)
  209.         return new PasteCommand(tv, txtsrc); 
  210.         return new MoveTextCommand(tv, from, to, dst);
  211.     }
  212.     return gNoChanges;
  213.     }
  214.     return this;
  215. }
  216.  
  217. void DragAndDropSelector::TrackFeedback(Point, Point np, bool)
  218. {
  219.     Point p;
  220.     int line;
  221.     np= np-tv->GetInnerOrigin();
  222.     tv->PointToPoint(np, &p, &line, &dst);
  223.     if (dst < from || dst >= to)
  224.     DrawCaretFeedback(dst);
  225. }
  226.  
  227. void DragAndDropSelector::DrawCaretFeedback(int at)
  228. {
  229.     int l;
  230.     Point p;
  231.     tv->CharToPoint(at, &l, &p);
  232.     p+= tv->GetInnerOrigin();
  233.     int bh= tv->BaseHeight(l);
  234.     
  235.     GrSetInk(gInkXor);
  236.     GrMoveto(p);
  237.     GrLineto(Point(p.x, p.y+bh));
  238. }
  239.  
  240. //----- TextCommand Methods ----------------------------------------------------
  241.  
  242. NewAbstractMetaImpl(TextCommand, Command, (TP(tv), TP(oldText), T(oldStart), T(oldEnd)));
  243.  
  244. TextCommand::TextCommand (TextView *t, int cmdNo, char *cmdName, bool save)
  245.                             : Command(cmdNo, cmdName)
  246. {
  247.     tv= t;
  248.     tv->GetSelection(&oldStart, &oldEnd);
  249.     oldText= (Text*)tv->GetText()->New();
  250.     if (save && oldStart != oldEnd) // save old text
  251.     tv->Copy(oldText);
  252. }
  253.  
  254. TextCommand::~TextCommand ()
  255. {
  256.     SafeDelete(oldText);
  257. } 
  258.  
  259. void TextCommand::RestoreSelection ()
  260. {
  261.     tv->SetSelection(oldStart, oldEnd, FALSE);
  262. }
  263.  
  264. void TextCommand::RedoIt()
  265. {
  266.     RestoreSelection();
  267.     DoIt();
  268.     tv->RevealSelection();
  269. }
  270.  
  271. //----- CutCopyCommand Methods -------------------------------------------------
  272.  
  273. NewMetaImpl0(CutCopyCommand, TextCommand);
  274.  
  275. CutCopyCommand::CutCopyCommand(TextView *t, int cmdNo, char *cmdName) 
  276.                 : TextCommand(t, cmdNo, 0, cmdNo != cCOPY)
  277. { 
  278.     if (cmdName == 0) {
  279.     if (cmdNo == cCUT)
  280.         cmdName= "Cut Text";
  281.     else if (cmdNo == cCOPY) 
  282.         cmdName= "Copy Text";
  283.     }
  284.     SetName(cmdName);
  285.     if (cmdNo == cCOPY)
  286.     SetType(eCmdTypeNoChange);
  287. }
  288.  
  289. void CutCopyCommand::DoIt()
  290. {
  291.     if (GetId() == cCOPY)
  292.     return;
  293.     tv->Cut();
  294.     tv->RevealSelection();
  295. }  
  296.  
  297. void CutCopyCommand::UndoIt()
  298. {
  299.     Text *t= tv->GetText();    
  300.  
  301.     if (GetId() == cCUT) {
  302.     tv->SetSelection(oldStart, oldStart, FALSE);
  303.     if (oldText->End() != 0) 
  304.         tv->Paste(oldText);
  305.     RestoreSelection();
  306.     tv->RevealSelection();
  307.     }
  308. }
  309.  
  310. //----- Paste Command Methods --------------------------------------------------
  311.  
  312. NewMetaImpl(PasteCommand, TextCommand, (TP(pastetext), T(newStart), T(newEnd)));
  313.  
  314. PasteCommand::PasteCommand(TextView *t, Text *pt, int cmdNo, char *cmdName) 
  315.             : TextCommand(t, cmdNo, cmdName ? cmdName : "Paste Text")
  316. {
  317.     pastetext= pt;
  318. }
  319.  
  320. PasteCommand::~PasteCommand()
  321. {
  322.     SafeDelete(pastetext);
  323. }
  324.  
  325. void PasteCommand::DoIt()
  326. {
  327.     tv->Paste(pastetext);
  328.     tv->GetSelection(&newStart, &newEnd);
  329.     tv->RevealSelection();
  330. }  
  331.  
  332. void PasteCommand::UndoIt()
  333. {
  334.     tv->SetSelection(oldStart, newEnd, FALSE);
  335.     tv->Cut();
  336.     if (oldText->End() != 0)
  337.     tv->Paste(oldText);
  338.     RestoreSelection();
  339.     tv->RevealSelection();
  340. }
  341.  
  342. //---- MoveTextCommand -------------------------------------------------------
  343.  
  344. MoveTextCommand::MoveTextCommand(TextView *tview, int f, int t, int d) 
  345.                         : Command(cPASTE, "Move Text")
  346. {
  347.     tv= tview;
  348.     from= f;
  349.     to= t;
  350.     dst= d;
  351.     mt= 0;
  352. }
  353.  
  354. MoveTextCommand::~MoveTextCommand()
  355. {
  356.     SafeDelete(mt);
  357. }
  358.  
  359. void MoveTextCommand::DoIt()
  360. {
  361.     int nd= dst;
  362.     if (dst > from)
  363.     nd= nd-(to-from);
  364.     if (!mt)
  365.     mt= tv->GetText()->Save(from, to);
  366.     tv->SetSelection(from, to, FALSE);
  367.     tv->Cut();
  368.     tv->SetSelection(nd, nd, FALSE);
  369.     tv->Paste(mt);
  370.     tv->SetSelection(nd, nd+to-from, FALSE);
  371.     tv->RevealSelection();
  372. }  
  373.  
  374. void MoveTextCommand::UndoIt()
  375. {
  376.     int nd= dst;
  377.     if (dst > from)
  378.     nd= nd-(to-from);
  379.     tv->SetSelection(nd, nd+to-from, FALSE);
  380.     tv->Cut();
  381.     tv->SetSelection(from, from, FALSE);
  382.     tv->Paste(mt);
  383.     tv->SetSelection(from, to, FALSE);
  384.     tv->RevealSelection();
  385. }
  386.  
  387. //----- TypeInCommand Command Methods ------------------------------------------
  388.  
  389. NewMetaImpl(TypingCommand, TextCommand, 
  390.                    (TP(backspaceBuf), TP(newText), T(newStart)));
  391.  
  392. TypingCommand::TypingCommand(TextView *t, int cmdNo, char *cmdName) 
  393.                            : TextCommand(t, cmdNo, cmdName) 
  394. {
  395.     Text *txt= tv->GetText();
  396.     backspaceBuf= (Text*) txt->New();
  397.     newText= (Text*) txt->New();
  398.     newStart= oldStart;
  399. }
  400.  
  401. TypingCommand::~TypingCommand()
  402. {
  403.     tv->TypingDeleted(this);
  404.     SafeDelete(backspaceBuf);
  405.     SafeDelete(newText);
  406. }
  407.  
  408. void TypingCommand::UndoIt()
  409. {
  410.     Text *t= tv->GetText();
  411.     int firstNewChar;
  412.  
  413.     firstNewChar= Math::Min(oldStart - backspaceBuf->End(), oldStart);
  414.     if (firstNewChar != newStart) {                     // save new text
  415.     t->Copy(newText, firstNewChar, newStart);         
  416.     tv->SetSelection(firstNewChar, newStart, TRUE);
  417.     tv->Cut();                                      // remove new text
  418.     } else
  419.     tv->SetSelection(firstNewChar, newStart, TRUE);
  420.     if (backspaceBuf->End() != 0)                            
  421.     tv->Paste(backspaceBuf);                        // insert saved text
  422.     if (oldText->End() != 0)
  423.     tv->Paste(oldText);
  424.     RestoreSelection();
  425.     tv->RevealSelection();
  426. }
  427.  
  428. void TypingCommand::RedoIt()
  429. {
  430.     RestoreSelection();
  431.     tv->Cut();
  432.     if (backspaceBuf->End() != 0) {
  433.     tv->SetSelection(oldStart - backspaceBuf->End(), oldStart, FALSE);
  434.     tv->Cut();        
  435.     }
  436.     if (newText->End() != 0)
  437.     tv->Paste(newText);
  438.     tv->RevealSelection();
  439. }
  440.  
  441. void TypingCommand::AddChar(int n)
  442. { 
  443.     newStart+= n; 
  444. }
  445.  
  446. void TypingCommand::DelChar()
  447. {
  448.     Text *t= tv->GetText();
  449.  
  450.     if (newStart > 0)
  451.     newStart--;  
  452.     if (newStart < oldStart) 
  453.     if (oldStart - newStart > backspaceBuf->End()) { // char already saved??
  454.         backspaceBuf->ReplaceRange(0, 0, t, newStart, newStart+1);
  455.     }
  456. }
  457.  
  458. //---- class CharStyleCommand -------------------------------------------------------
  459.  
  460. NewMetaImpl(CharStyleCommand, TextCommand, (TP(newStyles), TP(oldStyles), TP(tvp), TE(mode)));
  461.  
  462. CharStyleCommand::CharStyleCommand(TextView *t, int cmdNo, char *cmdName, 
  463.        TxtCharProp m, const CharStyleSpec &ns) 
  464.                     : TextCommand(t, cmdNo, cmdName, FALSE)
  465. {
  466.     st= Guard(t->GetText(), StyledText);
  467.     newStyles= oldStyles= 0;
  468.     tvp= t; 
  469.     style= ns;
  470.     mode= m;
  471. }
  472.  
  473. CharStyleCommand::~CharStyleCommand()
  474. {
  475.     SafeDelete(oldStyles);
  476.     SafeDelete(newStyles);
  477. }
  478.  
  479. void CharStyleCommand::DoIt()
  480. {
  481.     int from, to;
  482.  
  483.     tvp->GetSelection(&from, &to);
  484.     if (tvp->Caret())
  485.     st->SetCharStyle(mode, from, to, style);
  486.     else {    
  487.     if (oldStyles == 0) 
  488.         oldStyles= new RunArray;
  489.     st->GetCharStyles()->Copy(oldStyles, from, to);
  490.     st->SetCharStyle(mode, from, to, style);
  491.     }
  492.     tvp->RevealSelection();
  493. }  
  494.  
  495. void CharStyleCommand::UndoIt()
  496. {
  497.     if (oldStart == oldEnd)
  498.     st->ResetCurrentCharStyle();
  499.     else {
  500.     if (newStyles == 0) {
  501.         newStyles= new RunArray;
  502.         st->GetCharStyles()->Copy(newStyles, oldStart, oldEnd);
  503.     }
  504.     st->ReplaceCharStyles(oldStyles, oldStart, oldEnd); 
  505.     }
  506.     RestoreSelection();
  507.     tvp->RevealSelection();
  508. }
  509.  
  510. void CharStyleCommand::RedoIt()
  511. {
  512.     if (oldStart == oldEnd)
  513.     st->SetCharStyle(mode, oldStart, oldEnd, style);        
  514.     else
  515.     st->ReplaceCharStyles(newStyles, oldStart, oldEnd); 
  516.     RestoreSelection();
  517.     tvp->RevealSelection();
  518. }
  519.  
  520.  
  521. //---- class ParaStyleCommand -------------------------------------------------------
  522.  
  523. NewMetaImpl(ParaStyleCommand, TextCommand, (TP(newStyles), TP(oldStyles), TP(tvp)));
  524.  
  525. ParaStyleCommand::ParaStyleCommand(
  526.     TextView *t, int cmdNo, char *cmdName, TxtParaProp p, const ParaDesc &newStyle
  527. ): TextCommand(t, cmdNo, cmdName, FALSE)
  528. {
  529.     st= Guard(t->GetText(), StyledText);
  530.     newStyles= oldStyles= 0;
  531.     tvp= t; 
  532.     mode= p;
  533.     style= newStyle;
  534.     notify= 0;
  535. }
  536.  
  537. ParaStyleCommand::~ParaStyleCommand()
  538. {
  539.     SafeDelete(oldStyles);
  540.     SafeDelete(newStyles);
  541.     if (notify)
  542.     notify->Control(cIdNone, cPartCommandDone, this);
  543. }
  544.  
  545. void ParaStyleCommand::DoIt()
  546. {
  547.     int from, to, dd;
  548.  
  549.     tvp->GetSelection(&from, &to);
  550.     st->GetParaRange(from, &oldStart, &dd);
  551.     if (to == from)
  552.     oldEnd= dd;
  553.     else if (st->IsPara((*st)[to-1]))
  554.     oldEnd= to;
  555.     else
  556.     st->GetParaRange(to, &dd, &oldEnd);
  557.     if (oldStyles == 0) {
  558.     oldStyles= new RunArray; 
  559.     st->GetParaStyles()->Copy(oldStyles, oldStart, oldEnd);
  560.     }
  561.     st->SetParaStyle(mode, oldStart, oldEnd, style);
  562.     tvp->RevealSelection();
  563. }  
  564.  
  565. void ParaStyleCommand::UndoIt()
  566. {
  567.     if (newStyles == 0) {
  568.     newStyles= new RunArray;
  569.     st->GetParaStyles()->Copy(newStyles, oldStart, oldEnd);
  570.     }
  571.     st->ReplaceParaStyles(oldStyles, oldStart, oldEnd); 
  572.     RestoreSelection();
  573.     tvp->RevealSelection();
  574. }
  575.  
  576. void ParaStyleCommand::RedoIt()
  577. {
  578.     st->ReplaceParaStyles(newStyles, oldStart, oldEnd); 
  579.     RestoreSelection();
  580.     tvp->RevealSelection();
  581. }
  582.  
  583. void ParaStyleCommand::Apply(TxtParaProp p, const ParaDesc &newStyle)
  584. {
  585.     mode= p;
  586.     style= newStyle;
  587. }
  588.  
  589. void ParaStyleCommand::NotifyWhenDone(EvtHandler *evt)
  590. {
  591.     notify= evt;
  592. }
  593.  
  594. TxtParaProp ParaStyleCommand::GetNewStyle(ParaDesc &newStyle)
  595. {
  596.     newStyle= style;
  597.     return mode;    
  598. }
  599.  
  600.